#include <iostream>

using namespace std;
// 类的声明
class Person {
public:
	int* age;
	Person(int x_age);
	~Person();
	Person(const Person& p) {
		cout << "拷贝构造函数" << endl;
		this->age = new int(*p.age);
	}
	Person operator+(const Person& p1);
	Person& operator=(Person& p) {
		cout << "operator= init." << endl;
		*this->age = *p.age;
		return *this;
	}
};
// 类成员的实现
Person::Person(int x_age):age(new int(x_age)) {}
Person::~Person() {
	if (this->age != NULL) {
		delete this->age;
		this->age = NULL;
	}
}
Person Person::operator+(const Person& p1) {
	Person p(0);
	*p.age = *p1.age + *this->age;
	return p;
}
 // 全局操作符重载函数 和 成员 操作符重载函数 可以同时存在;
// 全局操作符重载函数 似乎可以 覆盖掉 成员操作符重载函数
Person operator+(const Person& p1, const Person& p2) {
	Person p(0);
	*p.age = *p1.age + *p2.age + 10;
	return p;
}
// 重载 "<<" 操作符, 由于成员函数运算符重载 左值只能是Person, 而我们需要左值是ostream,
// 所以只能用全局函数 运算符重载
ostream& operator<<(ostream& out, const Person& p) {
	return out << "person age is " <<  *p.age;
}
// 前置自增运算符 ++a
Person& operator++(Person& p) {
	// 1.复制本体 2.本体自增 3.返回复制体
	(*p.age)++;
	return p;
}
// 后置自增运算符 a++
// int a=1;  a++ 返回的实际是个常量 
const Person operator++(Person& p, int) {
	// 1.复制本体 2.本体自增 3.返回复制体
	Person old(p);
	(*p.age)++;
	return old;
}
void test() {
	Person p{12};
	Person p2{12};

	Person p_sum = p + p2;
	cout << "p_sum`s age is " <<  *p_sum.age << endl;
	cout << p << endl;
	
	cout << "Person++ is " << *(p++).age << endl; // 12
	cout << "Person age is " << *(++p).age << endl; // 14
}
// 赋值运算符 重载测试
void test2() {
	Person p(1);
	Person p2(2);
	Person p3(3);

	cout << p << endl
		<< p2 << endl
		<< p3 << endl;

	p3 = p2 = p;

	cout << p << endl
		<< p2 << endl
		<< p3 << endl;
}
// 赋值= 时调用 对象的运算符重载对应的方法；对象创建初始化时调用的是 拷贝构造函数
void test3() {
	Person p(10);
	//Person p2 = p;
	Person p2(0);
	p2 = p;
	cout << "p2 " << p2 << endl;
}
int main() {
	test2();
	//test3();
	return 0;
}